TypeScript Kimlik Doğrulaması: Küresel Uygulamalar İçin JWT Tür Güvenliği Desenleri

Günümüzün birbirine bağlı dünyasında, güvenli ve güvenilir küresel uygulamalar oluşturmak çok önemlidir. Bir kullanıcının kimliğini doğrulama süreci olan kimlik doğrulama, hassas verileri korumada ve yetkili erişimi sağlamada kritik bir rol oynar. JSON Web Belirteçleri (JWT'ler), basitlikleri ve taşınabilirlikleri nedeniyle kimlik doğrulamayı uygulamak için popüler bir seçim haline geldi. TypeScript'in güçlü tür sistemiyle birleştirildiğinde, JWT kimlik doğrulaması, özellikle büyük ölçekli, uluslararası projeler için daha da sağlam ve sürdürülebilir hale getirilebilir.

JWT Kimlik Doğrulaması İçin Neden TypeScript Kullanmalısınız?

TypeScript, kimlik doğrulama sistemleri oluştururken çeşitli avantajlar sunar:

• Tür Güvenliği: TypeScript'in statik tiplemesi, çalışma zamanı sürprizleri riskini azaltarak geliştirme sürecinin başlarında hataları yakalamaya yardımcı olur. Bu, kimlik doğrulama gibi güvenliğe duyarlı bileşenler için çok önemlidir.
• Gelişmiş Kod Sürdürülebilirliği: Türler, özellikle birden fazla geliştiricinin dahil olabileceği karmaşık küresel uygulamalarda, kodu anlamayı, değiştirmeyi ve yeniden düzenlemeyi kolaylaştıran net sözleşmeler ve belgeler sağlar.
• Gelişmiş Kod Tamamlama ve Araçlar: TypeScript uyumlu IDE'ler, geliştirici üretkenliğini artıran daha iyi kod tamamlama, gezinme ve yeniden düzenleme araçları sunar.
• Azaltılmış Boilerplate: Arayüzler ve jenerikler gibi özellikler, boilerplate kodu azaltmaya ve kodun yeniden kullanılabilirliğini artırmaya yardımcı olabilir.

JWT'leri Anlamak

JWT, iki taraf arasında aktarılacak talepleri temsil etmenin kompakt, URL güvenli bir yoludur. Üç bölümden oluşur:

1. Başlık: Algoritmayı ve belirteç türünü belirtir.
2. Yük: Kullanıcı kimliği, rolleri ve sona erme zamanı gibi talepleri içerir.
3. İmza: Gizli bir anahtar kullanarak belirtecin bütünlüğünü sağlar.

JWT'ler genellikle kimlik doğrulama için kullanılır, çünkü her istek için bir veritabanına sorgu göndermeye gerek kalmadan sunucu tarafında kolayca doğrulanabilirler. Ancak, hassas bilgileri doğrudan JWT yükünde saklamak genellikle önerilmez.

TypeScript'te Tür Güvenli JWT Kimlik Doğrulaması Uygulama

TypeScript'te tür güvenli JWT kimlik doğrulama sistemleri oluşturmak için bazı desenleri keşfedelim.

1. Arayüzlerle Yük Türlerini Tanımlama

JWT yükünüzün yapısını temsil eden bir arayüz tanımlayarak başlayın. Bu, belirteç içindeki taleplere erişirken tür güvenliğine sahip olmanızı sağlar.

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  iat: number; // Veriliş Zamanı (zaman damgası)
  exp: number; // Sona Erme Zamanı (zaman damgası)
}

Bu arayüz, JWT yükünün beklenen şeklini tanımlar. Belirtecin geçerliliğini yönetmek için çok önemli olan `iat` (veriliş zamanı) ve `exp` (sona erme zamanı) gibi standart JWT taleplerini ekledik. Uygulamanızla ilgili diğer talepleri, örneğin kullanıcı rolleri veya izinleri ekleyebilirsiniz. Belirteç boyutunu en aza indirmek ve güvenliği artırmak için talepleri yalnızca gerekli bilgilerle sınırlamak iyi bir uygulamadır.

Örnek: Küresel Bir E-ticaret Platformunda Kullanıcı Rollerini Yönetme

Dünya çapındaki müşterilere hizmet veren bir e-ticaret platformu düşünün. Farklı kullanıcıların farklı rolleri vardır:

• Yönetici: Ürünleri, kullanıcıları ve siparişleri yönetmek için tam erişim.
• Satıcı: Kendi ürünlerini ekleyebilir ve yönetebilir.
• Müşteri: Ürünlere göz atabilir ve satın alabilir.

`JwtPayload` içindeki `roller` dizisi bu rolleri temsil etmek için kullanılabilir. `roller` özelliğini, kullanıcının erişim haklarını ayrıntılı bir şekilde temsil eden daha karmaşık bir yapıya genişletebilirsiniz. Örneğin, kullanıcının satıcı olarak faaliyet göstermesine izin verilen ülkelerin bir listesine veya kullanıcının yönetici erişimine sahip olduğu mağazaların bir dizisine sahip olabilirsiniz.

2. Türlü Bir JWT Hizmeti Oluşturma

JWT oluşturma ve doğrulamayı işleyen bir hizmet oluşturun. Bu hizmet, tür güvenliğini sağlamak için `JwtPayload` arayüzünü kullanmalıdır.

import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key'; // Güvenli bir şekilde saklayın!

class JwtService {
  static sign(payload: Omit, expiresIn: string = '1h'): string {
    const now = Math.floor(Date.now() / 1000);
    const payloadWithTimestamps: JwtPayload = {
        ...payload,
        iat: now,
        exp: now + parseInt(expiresIn) * 60 * 60,
    };
    return jwt.sign(payloadWithTimestamps, JWT_SECRET);
  }

  static verify(token: string): JwtPayload | null {
    try {
      const decoded = jwt.verify(token, JWT_SECRET) as JwtPayload;
      return decoded;
    } catch (error) {
      console.error('JWT verification error:', error);
      return null;
    }
  }
}

Bu hizmet iki yöntem sağlar:

• `sign()`: Bir yükten bir JWT oluşturur. `iat` ve `exp`'nin otomatik olarak oluşturulmasını sağlamak için bir `Omit` alır. `JWT_SECRET`'ı güvenli bir şekilde, ideal olarak ortam değişkenlerini ve bir sır yönetim çözümünü kullanarak saklamak önemlidir.
• `verify()`: Bir JWT'yi doğrular ve geçerliyse kod çözülmüş yükü veya geçersizse `null` döndürür. Doğrulama sonrası bir tür bildirimi `as JwtPayload` kullanıyoruz, bu güvenlidir çünkü `jwt.verify` yöntemi ya bir hata fırlatır (`catch` bloğunda yakalanır) ya da tanımladığımız yük yapısıyla eşleşen bir nesne döndürür.

Önemli Güvenlik Hususları:

• Gizli Anahtar Yönetimi: JWT gizli anahtarınızı asla kodunuza sabit kodlamayın. Ortam değişkenlerini veya özel bir sır yönetim hizmetini kullanın. Anahtarları düzenli olarak döndürün.
• Algoritma Seçimi: HS256 veya RS256 gibi güçlü bir imzalama algoritması seçin. `none` gibi zayıf algoritmalardan kaçının.
• Belirteç Sona Ermesi: Uzlaşılmış belirteçlerin etkisini sınırlamak için JWT'leriniz için uygun sona erme süreleri ayarlayın.
• Belirteç Depolama: JWT'leri istemci tarafında güvenli bir şekilde saklayın. Seçenekler arasında HTTP yalnızca tanımlama bilgileri veya XSS saldırılarına karşı uygun önlemlerle yerel depolama bulunur.

3. Ara Katman Yazılımı ile API Uç Noktalarını Koruma

`Authorization` başlığındaki JWT'yi doğrulayarak API uç noktalarınızı korumak için ara katman yazılımı oluşturun.

import { Request, Response, NextFunction } from 'express';

interface RequestWithUser extends Request {
  user?: JwtPayload;
}

function authenticate(req: RequestWithUser, res: Response, next: NextFunction) {
  const authHeader = req.headers.authorization;

  if (!authHeader) {
    return res.status(401).json({ message: 'Yetkisiz' });
  }

  const token = authHeader.split(' ')[1]; // Varsayılan Bearer belirteci
  const decoded = JwtService.verify(token);

  if (!decoded) {
    return res.status(401).json({ message: 'Geçersiz belirteç' });
  }

  req.user = decoded;
  next();
}

export default authenticate;

Bu ara katman yazılımı, JWT'yi `Authorization` başlığından ayıklar, `JwtService` kullanarak doğrular ve çözülmüş yükü `req.user` nesnesine ekler. Ayrıca, Express.js'den standart `Request` arayüzünü genişleten, `JwtPayload | undefined` türünde bir `user` özelliği ekleyen bir `RequestWithUser` arayüzü tanımlıyoruz. Bu, korunan rotalarda kullanıcı bilgilerine erişirken tür güvenliği sağlar.

Örnek: Küresel Bir Uygulamada Saat Dilimlerini Yönetme

Uygulamanızın farklı saat dilimlerinden kullanıcıların etkinlikleri planlamasına izin verdiğini hayal edin. Etkinlik saatlerini doğru bir şekilde görüntülemek için kullanıcının tercih ettiği saat dilimini JWT yükünde saklamak isteyebilirsiniz. `JwtPayload` arayüzüne bir `timeZone` talebi ekleyebilirsiniz:

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  timeZone: string; // örneğin, 'America/Los_Angeles', 'Asia/Tokyo'
  iat: number;
  exp: number;
}

Ardından, ara katman yazılımınızda veya rota işleyicilerinizde, tarihleri ve saatleri kullanıcının tercihine göre biçimlendirmek için `req.user.timeZone` erişebilirsiniz.

4. Rota İşleyicilerinde Kimliği Doğrulanmış Kullanıcıyı Kullanma

Korunan rota işleyicilerinizde, artık kimliği doğrulanmış kullanıcının bilgilerine `req.user` nesnesi aracılığıyla tam tür güvenliği ile erişebilirsiniz.

import express, { Request, Response } from 'express';
import authenticate from './middleware/authenticate';

const app = express();

app.get('/profile', authenticate, (req: Request, res: Response) => {
  const user = (req as any).user; // veya RequestWithUser kullanın
  res.json({ message: `Merhaba, ${user.email}!`, userId: user.userId });
});

Bu örnek, kimliği doğrulanmış kullanıcının e-postasının ve kimliğinin `req.user` nesnesinden nasıl erişileceğini gösterir. `JwtPayload` arayüzünü tanımladığımız için, TypeScript `user` nesnesinin beklenen yapısını bilir ve tür denetimi ve kod tamamlama sağlayabilir.

5. Rol Tabanlı Erişim Kontrolü (RBAC) Uygulama

Daha hassas erişim kontrolü için, JWT yükünde depolanan rollere göre RBAC uygulayabilirsiniz.

function authorize(roles: string[]) {
  return (req: RequestWithUser, res: Response, next: NextFunction) => {
    const user = req.user;

    if (!user || !user.roles.some(role => roles.includes(role))) {
      return res.status(403).json({ message: 'Yasak' });
    }

    next();
  };
}

Bu `authorize` ara katman yazılımı, kullanıcının rollerinin gerekli rollerden herhangi birini içerip içermediğini denetler. Aksi takdirde, 403 Yasak hatası döndürür.

app.get('/admin', authenticate, authorize(['admin']), (req: Request, res: Response) => {
  res.json({ message: 'Hoş geldiniz, Yönetici!' });
});

Bu örnek, kullanıcının `admin` rolüne sahip olmasını gerektiren `/admin` rotasını korur.

Örnek: Küresel Bir Uygulamada Farklı Para Birimlerini Yönetme

Uygulamanız finansal işlemleri yönetiyorsa, birden fazla para birimini desteklemeniz gerekebilir. Kullanıcının tercih ettiği para birimini JWT yükünde saklayabilirsiniz:

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  currency: string; // örneğin, 'USD', 'EUR', 'JPY'
  iat: number;
  exp: number;
}

Ardından, arka uç mantığınızda, fiyatları biçimlendirmek ve gerektiğinde para birimi dönüştürmeleri gerçekleştirmek için `req.user.currency` kullanabilirsiniz.

6. Yenileme Belirteçleri

JWT'ler tasarım gereği kısa ömürlüdür. Kullanıcıların sık sık oturum açmasını önlemek için yenileme belirteçleri uygulayın. Yenileme belirteci, kullanıcının kimlik bilgilerini yeniden girmesini gerektirmeden yeni bir erişim belirteci (JWT) almak için kullanılabilen uzun ömürlü bir belirteçtir. Yenileme belirteçlerini bir veritabanında güvenli bir şekilde saklayın ve kullanıcıyla ilişkilendirin. Bir kullanıcının erişim belirtecinin süresi dolduğunda, yeni bir tane istemek için yenileme belirtecini kullanabilir. Bu işlemin güvenlik açıklarını önlemek için dikkatli bir şekilde uygulanması gerekir.

Gelişmiş Tür Güvenliği Teknikleri

1. Ayrıntılı Kontrol için Ayrımcı Birleşimler

Bazen, kullanıcının rolüne veya istek türüne göre farklı JWT yüklerine ihtiyacınız olabilir. Ayrımcı birleşimler, bunu tür güvenliği ile elde etmenize yardımcı olabilir.

interface AdminJwtPayload {
  type: 'admin';
  userId: string;
  email: string;
  roles: string[];
  iat: number;
  exp: number;
}

interface UserJwtPayload {
  type: 'user';
  userId: string;
  email: string;
  iat: number;
  exp: number;
}

type JwtPayload = AdminJwtPayload | UserJwtPayload;

function processToken(payload: JwtPayload) {
  if (payload.type === 'admin') {
    console.log('Yönetici e-postası:', payload.email); // E-postaya erişmek güvenli
  } else {
    // payload.email burada erişilebilir değil çünkü tür 'user'
    console.log('Kullanıcı Kimliği:', payload.userId);
  }
}

Bu örnek, iki farklı JWT yük türü, `AdminJwtPayload` ve `UserJwtPayload` tanımlar ve bunları ayrımcı bir birleşim `JwtPayload` içinde birleştirir. `type` özelliği bir ayrımcı görevi görür ve yük türüne göre özelliklere güvenli bir şekilde erişmenizi sağlar.

2. Yeniden Kullanılabilir Kimlik Doğrulama Mantığı için Jenerikler

Farklı yük yapılarına sahip birden fazla kimlik doğrulama şemanız varsa, yeniden kullanılabilir kimlik doğrulama mantığı oluşturmak için jenerikler kullanabilirsiniz.

interface BaseJwtPayload {
  userId: string;
  iat: number;
  exp: number;
}

function verifyToken(token: string): T | null {
  try {
    const decoded = jwt.verify(token, JWT_SECRET) as T;
    return decoded;
  } catch (error) {
    console.error('JWT doğrulama hatası:', error);
    return null;
  }
}

const adminToken = verifyToken('admin-token');
if (adminToken) {
  console.log('Yönetici e-postası:', adminToken.email);
}

Bu örnek, `BaseJwtPayload`'ı genişleten bir jenerik tür `T` alan bir `verifyToken` işlevi tanımlar. Bu, tümünün en azından `userId`, `iat` ve `exp` özelliklerine sahip olmasını sağlarken farklı yük yapılarına sahip belirteçleri doğrulamanıza olanak tanır.

Küresel Uygulama Hususları

Küresel uygulamalar için kimlik doğrulama sistemleri oluştururken, aşağıdakileri göz önünde bulundurun:

• Yerelleştirme: Hata mesajlarının ve kullanıcı arayüzü öğelerinin farklı diller ve bölgeler için yerelleştirildiğinden emin olun.
• Saat Dilimleri: Belirteç sona erme sürelerini ayarlarken ve kullanıcılara tarihleri ve saatleri görüntülerken saat dilimlerini doğru bir şekilde yönetin.
• Veri Gizliliği: GDPR ve CCPA gibi veri gizliliği düzenlemelerine uyun. JWT'lerde depolanan kişisel veri miktarını en aza indirin.
• Erişilebilirlik: Kimlik doğrulama akışlarınızı engelli kullanıcılar için erişilebilir olacak şekilde tasarlayın.
• Kültürel Duyarlılık: Kullanıcı arayüzlerini ve kimlik doğrulama akışlarını tasarlarken kültürel farklılıklara dikkat edin.

Sonuç

TypeScript'in tür sisteminden yararlanarak, küresel uygulamalar için sağlam ve sürdürülebilir JWT kimlik doğrulama sistemleri oluşturabilirsiniz. Arayüzlerle yük türlerini tanımlamak, türlü JWT hizmetleri oluşturmak, API uç noktalarını ara katman yazılımı ile korumak ve RBAC uygulamak, güvenliği ve tür güvenliğini sağlamada temel adımlardır. Yerelleştirme, saat dilimleri, veri gizliliği, erişilebilirlik ve kültürel duyarlılık gibi küresel uygulama hususlarını göz önünde bulundurarak, çeşitli uluslararası bir kitle için kapsayıcı ve kullanıcı dostu olan kimlik doğrulama deneyimleri oluşturabilirsiniz. JWT'leri işlerken her zaman güvenli anahtar yönetimi, algoritma seçimi, belirteç sona ermesi ve belirteç depolama dahil olmak üzere güvenlik en iyi uygulamalarına öncelik vermeyi unutmayın. Küresel uygulamalarınız için güvenli, ölçeklenebilir ve güvenilir kimlik doğrulama sistemleri oluşturmak için TypeScript'in gücünü kucaklayın.